async def deregister_agent(self):
    """
    Deregisters the agent for the Agentic Table by updating the sheet state to IDLE.

    Raises:
        LockedAgenticTableError: If the Agentic Table is busy.
    """
    await AgenticTable.update_sheet_state(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        state=AgenticTableSheetState.IDLE,
    )

async def get_cell(
    self, row: int, column: int, include_row_metadata: bool = True
) -> MagicTableCell:
    """
    Gets the value of a cell in the Agentic Table.

    Args:
        row (int): The row index.
        column (int): The column index.
        include_row_metadata (bool): Whether to include the row metadata. Defaults to True.

    Returns:
        MagicTableCell: The MagicTableCell object.

    """
    cell_data = await AgenticTable.get_cell(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        rowOrder=row,
        columnOrder=column,
        includeRowMetadata=include_row_metadata,  # type: ignore[arg-type]
    )
    return MagicTableCell.model_validate(cell_data)

async def get_num_rows(self) -> int:
    """
    Gets the number of rows in the Agentic Table.

    Returns:
        int: The number of rows in the Agentic Table.
    """
    sheet_info = await AgenticTable.get_sheet_data(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        includeRowCount=True,
        includeCells=False,
        includeLogHistory=False,
    )
    return sheet_info["magicTableRowCount"]

async def get_sheet(
    self,
    start_row: int = 0,
    end_row: int | None = None,
    batch_size: int = 100,
    include_log_history: bool = False,
    include_cell_meta_data: bool = False,
    include_row_metadata: bool = False,
) -> MagicTableSheet:
    """
    Gets the sheet data from the Agentic Table paginated by batch_size.

    Args:
        start_row (int): The start row (inclusive).
        end_row (int | None): The end row (not inclusive).
        batch_size (int): The batch size.
        include_log_history (bool): Whether to include the log history.
        include_cell_meta_data (bool): Whether to include the cell metadata (renderer, selection, agreement status).
        include_row_metadata (bool): Whether to include the row metadata (key value pairs).
    Returns:
        MagicTableSheet: The sheet data.
    """
    # Find the total number of rows
    sheet_info = await AgenticTable.get_sheet_data(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        includeRowCount=True,
        includeCells=False,
        includeLogHistory=False,
        includeCellMetaData=False,
    )
    total_rows = sheet_info["magicTableRowCount"]
    if end_row is None or end_row > total_rows:
        end_row = total_rows
    if start_row > end_row:
        raise Exception("Start row is greater than end row")
    if start_row < 0 or end_row < 0:
        raise Exception("Start row or end row is negative")

    # Get the cells
    cells = []
    for row in range(start_row, end_row, batch_size):
        end_row_batch = min(row + batch_size, end_row)
        sheet_partial = await AgenticTable.get_sheet_data(
            user_id=self._user_id,
            company_id=self._company_id,
            tableId=self.table_id,
            includeCells=True,
            includeLogHistory=include_log_history,
            includeRowCount=False,
            includeCellMetaData=include_cell_meta_data,  # renderer, selection, agreement status
            startRow=row,
            endRow=end_row_batch - 1,
        )
        if "magicTableCells" in sheet_partial:
            if include_row_metadata:
                # If include_row_metadata is true, we need to get the row metadata for each cell.
                row_metadata_map = {}
                # TODO: @thea-unique This routine is not efficient and would be nice if we had this data passed on in get_sheet_data.
                for cell in sheet_partial["magicTableCells"]:
                    row_order = cell.get("rowOrder")  # type: ignore[assignment]
                    if row_order is not None and row_order not in row_metadata_map:
                        column_order = cell.get("columnOrder")  # type: ignore[assignment]
                        self.logger.info(
                            f"Getting row metadata for cell {row_order}, {column_order}"
                        )
                        cell_with_row_metadata = await self.get_cell(
                            row_order,
                            column_order,  # type: ignore[arg-type]
                        )
                        if cell_with_row_metadata.row_metadata:
                            print(cell_with_row_metadata.row_metadata)
                            row_metadata_map[cell_with_row_metadata.row_order] = (
                                cell_with_row_metadata.row_metadata
                            )
                            cell["rowMetadata"] = (  # type: ignore[assignment]
                                cell_with_row_metadata.row_metadata
                            )
                # Assign row_metadata to all cells
                for cell in sheet_partial["magicTableCells"]:
                    row_order = cell.get("rowOrder")  # type: ignore[assignment]
                    if row_order is not None and row_order in row_metadata_map:
                        cell["rowMetadata"] = row_metadata_map[  # type: ignore[assignment]
                            row_order
                        ]

            cells.extend(sheet_partial["magicTableCells"])

    sheet_info["magicTableCells"] = cells
    return MagicTableSheet.model_validate(sheet_info)

async def get_sheet_metadata(self) -> list[RowMetadataEntry]:
    """
    Gets the sheet metadata from the Agentic Table.

    Returns:
        list[RowMetadataEntry]: The sheet metadata.
    """
    sheet_info = await AgenticTable.get_sheet_data(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        includeSheetMetadata=True,  # type: ignore[arg-type]
    )
    return [
        RowMetadataEntry.model_validate(metadata)
        for metadata in sheet_info["magicTableSheetMetadata"]
    ]

async def register_agent(self) -> None:
    """
    Registers the agent for the Agentic Table by updating the sheet state to PROCESSING.

    Raises:
        LockedAgenticTableError: If the Agentic Table is busy.
    """
    state = await AgenticTable.get_sheet_state(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
    )
    if state == AgenticTableSheetState.IDLE:
        await AgenticTable.update_sheet_state(
            user_id=self._user_id,
            company_id=self._company_id,
            tableId=self.table_id,
            state=AgenticTableSheetState.PROCESSING,
        )
        return
    # If the sheet is not idle, we cannot register the agent
    raise LockedAgenticTableError(
        f"Agentic Table is busy. Cannot register agent {self._event_id or self.table_id}."
    )

async def set_activity(
    self,
    text: str,
    activity: MagicTableAction,
    status: ActivityStatus = ActivityStatus.IN_PROGRESS,
):
    """
    Sets the activity of the Agentic Table.

    Args:
        activity (str): The activity to set.
    """
    await AgenticTable.set_activity(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        activity=activity.value,  # type: ignore[arg-type]
        status=status.value,  # type: ignore[arg-type]
        text=text,
    )

async def set_artifact(
    self,
    artifact_type: ArtifactType,
    content_id: str,
    mime_type: str,
    name: str,
):
    """Upload/set report files to the Agentic Table.

    Args:
        artifact_type (ArtifactType): The type of artifact to set.
        content_id (str): The content ID of the artifact.
        mime_type (str): The MIME type of the artifact.
        name (str): The name of the artifact.
    """
    await AgenticTable.set_artifact(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        artifactType=artifact_type.value,
        contentId=content_id,
        mimeType=mime_type,
        name=name,
    )

async def set_cell(
    self,
    row: int,
    column: int,
    text: str,
    log_entries: list[LogEntry] | None = None,
):
    """
    Sets the value of a cell in the Agentic Table.

    Args:
        row (int): The row index.
        column (int): The column index.
        text (str): The text to set.
        log_entries (Optional[list[LogEntry]]): The log entries to set.
    """
    if log_entries is None:
        log_entries_new = []
    else:
        log_entries_new = [
            log_entry.to_sdk_log_entry() for log_entry in log_entries
        ]
    try:
        await AgenticTable.set_cell(
            user_id=self._user_id,
            company_id=self._company_id,
            tableId=self.table_id,
            rowOrder=row,
            columnOrder=column,
            text=text,
            logEntries=log_entries_new,
        )
    except Exception as e:
        self.logger.error(f"Error setting cell {row}, {column}: {e}.")

async def set_cell_metadata(
    self,
    row: int,
    column: int,
    selected: bool | None = None,
    selection_method: SelectionMethod | None = None,
    agreement_status: AgreementStatus | None = None,
) -> None:
    """
    Sets the cell metadata for the Agentic Table.
    NOTE: This is not to be confused with the sheet metadata and is associated rather with selection and agreement status, row locking etc.

    Args:
        row (int): The row index.
        column (int): The column index.
        selected (bool | None): Whether the cell is selected.
        selection_method (SelectionMethod | None): The method of selection.
        agreement_status (AgreementStatus | None): The agreement status.
    """
    params = {}
    if selected is not None:
        params["selected"] = selected
    if selection_method is not None:
        params["selectionMethod"] = selection_method
    if agreement_status is not None:
        params["agreementStatus"] = agreement_status
    result = await AgenticTable.set_cell_metadata(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        rowOrder=row,
        columnOrder=column,
        **params,
    )
    if result["status"]:  # type: ignore
        return
    raise Exception(result["message"])  # type: ignore

async def set_column_style(
    self,
    column: int,
    width: int | None = None,
    cell_renderer: CellRendererTypes | None = None,
    filter: FilterTypes | None = None,
    editable: bool | None = None,
):
    """
    Sets the style of a column in the Agentic Table.

    Args:
        column (int): The column index.
        width (int | None, optional): The width of the column. Defaults to None.
        cell_renderer (CellRenderer | None, optional): The cell renderer of the column. Defaults to None.
        filter (FilterComponents | None, optional): The filter of the column. Defaults to None.
        editable (bool | None, optional): Whether the column is editable. Defaults to None.

    Raises:
        Exception: If the column style is not set.
    """
    # Convert the input to the correct format
    params = {}
    if width is not None:
        params["columnWidth"] = width
    if cell_renderer is not None:
        params["cellRenderer"] = cell_renderer.value
    if filter is not None:
        params["filter"] = filter.value
    if editable is not None:
        params["editable"] = editable
    status, message = await AgenticTable.set_column_metadata(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        columnOrder=column,
        **params,
    )
    if status:
        return
    raise Exception(message)

async def set_multiple_cells(
    self, cells: list[MagicTableCell], batch_size: int = 4000
):
    """
    Sets the values of multiple cells in the Agentic Table.

    Args:
        cells (list[MagicTableCell]): The cells to set sorted by row and column.
        batch_size (int): Number of cells to set in a single request.
    """
    for i in range(0, len(cells), batch_size):
        batch = cells[i : i + batch_size]
        await AgenticTable.set_multiple_cells(
            user_id=self._user_id,
            company_id=self._company_id,
            tableId=self.table_id,
            cells=[
                SDKAgenticTableCell(
                    rowOrder=cell.row_order,
                    columnOrder=cell.column_order,
                    text=cell.text,
                )
                for cell in batch
            ],
        )

async def update_row_verification_status(
    self,
    row_orders: list[int],
    status: RowVerificationStatus,
):
    """Update the verification status of multiple rows at once.

    Args:
        row_orders (list[int]): The row indexes to update.
        status (RowVerificationStatus): The verification status to set.
    """
    await AgenticTable.bulk_update_status(
        user_id=self._user_id,
        company_id=self._company_id,
        tableId=self.table_id,
        rowOrders=row_orders,
        status=status,
    )

def __copy__(self) -> Self:
    """Returns a shallow copy of the model."""
    cls = type(self)
    m = cls.__new__(cls)
    _object_setattr(m, '__dict__', copy(self.__dict__))
    _object_setattr(m, '__pydantic_extra__', copy(self.__pydantic_extra__))
    _object_setattr(m, '__pydantic_fields_set__', copy(self.__pydantic_fields_set__))

    if not hasattr(self, '__pydantic_private__') or self.__pydantic_private__ is None:
        _object_setattr(m, '__pydantic_private__', None)
    else:
        _object_setattr(
            m,
            '__pydantic_private__',
            {k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined},
        )

    return m

def __deepcopy__(self, memo: dict[int, Any] | None = None) -> Self:
    """Returns a deep copy of the model."""
    cls = type(self)
    m = cls.__new__(cls)
    _object_setattr(m, '__dict__', deepcopy(self.__dict__, memo=memo))
    _object_setattr(m, '__pydantic_extra__', deepcopy(self.__pydantic_extra__, memo=memo))
    # This next line doesn't need a deepcopy because __pydantic_fields_set__ is a set[str],
    # and attempting a deepcopy would be marginally slower.
    _object_setattr(m, '__pydantic_fields_set__', copy(self.__pydantic_fields_set__))

    if not hasattr(self, '__pydantic_private__') or self.__pydantic_private__ is None:
        _object_setattr(m, '__pydantic_private__', None)
    else:
        _object_setattr(
            m,
            '__pydantic_private__',
            deepcopy({k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined}, memo=memo),
        )

    return m

@classmethod
def __get_pydantic_json_schema__(
    cls,
    core_schema: CoreSchema,
    handler: GetJsonSchemaHandler,
    /,
) -> JsonSchemaValue:
    """Hook into generating the model's JSON schema.

    Args:
        core_schema: A `pydantic-core` CoreSchema.
            You can ignore this argument and call the handler with a new CoreSchema,
            wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
            or just call the handler with the original schema.
        handler: Call into Pydantic's internal JSON schema generation.
            This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
            generation fails.
            Since this gets called by `BaseModel.model_json_schema` you can override the
            `schema_generator` argument to that function to change JSON schema generation globally
            for a type.

    Returns:
        A JSON schema, as a Python object.
    """
    return handler(core_schema)

def __init__(self, /, **data: Any) -> None:
    """Create a new model by parsing and validating input data from keyword arguments.

    Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
    validated to form a valid model.

    `self` is explicitly positional-only to allow `self` as a field name.
    """
    # `__tracebackhide__` tells pytest and some other tools to omit this function from tracebacks
    __tracebackhide__ = True
    validated_self = self.__pydantic_validator__.validate_python(data, self_instance=self)
    if self is not validated_self:
        warnings.warn(
            'A custom validator is returning a value other than `self`.\n'
            "Returning anything other than `self` from a top level model validator isn't supported when validating via `__init__`.\n"
            'See the `model_validator` docs (https://docs.pydantic.dev/latest/concepts/validators/#model-validators) for more details.',
            stacklevel=2,
        )

def __init_subclass__(cls, **kwargs: Unpack[ConfigDict]):
    """This signature is included purely to help type-checkers check arguments to class declaration, which
    provides a way to conveniently set model_config key/value pairs.

    ```python
    from pydantic import BaseModel

    class MyModel(BaseModel, extra='allow'): ...
    ```

    However, this may be deceiving, since the _actual_ calls to `__init_subclass__` will not receive any
    of the config arguments, and will only receive any keyword arguments passed during class initialization
    that are _not_ expected keys in ConfigDict. (This is due to the way `ModelMetaclass.__new__` works.)

    Args:
        **kwargs: Keyword arguments passed to the class definition, which set model_config

    Note:
        You may want to override `__pydantic_init_subclass__` instead, which behaves similarly but is called
        *after* the class is fully initialized.
    """

def __iter__(self) -> TupleGenerator:
    """So `dict(model)` works."""
    yield from [(k, v) for (k, v) in self.__dict__.items() if not k.startswith('_')]
    extra = self.__pydantic_extra__
    if extra:
        yield from extra.items()

@classmethod
def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
    """This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
    only after basic class initialization is complete. In particular, attributes like `model_fields` will
    be present when this is called, but forward annotations are not guaranteed to be resolved yet,
    meaning that creating an instance of the class may fail.

    This is necessary because `__init_subclass__` will always be called by `type.__new__`,
    and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
    `type.__new__` was called in such a manner that the class would already be sufficiently initialized.

    This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
    any kwargs passed to the class definition that aren't used internally by Pydantic.

    Args:
        **kwargs: Any keyword arguments passed to the class definition that aren't used internally
            by Pydantic.

    Note:
        You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
        instead, which is called once the class and its fields are fully initialized and ready for validation.
    """

@classmethod
def __pydantic_on_complete__(cls) -> None:
    """This is called once the class and its fields are fully initialized and ready to be used.

    This typically happens when the class is created (just before
    [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
    except when forward annotations are used that could not immediately be resolved.
    In that case, it will be called later, when the model is rebuilt automatically or explicitly using
    [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
    """

@typing_extensions.deprecated(
    'The `copy` method is deprecated; use `model_copy` instead. '
    'See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.',
    category=None,
)
def copy(
    self,
    *,
    include: AbstractSetIntStr | MappingIntStrAny | None = None,
    exclude: AbstractSetIntStr | MappingIntStrAny | None = None,
    update: Dict[str, Any] | None = None,  # noqa UP006
    deep: bool = False,
) -> Self:  # pragma: no cover
    """Returns a copy of the model.

    !!! warning "Deprecated"
        This method is now deprecated; use `model_copy` instead.

    If you need `include` or `exclude`, use:

    ```python {test="skip" lint="skip"}
    data = self.model_dump(include=include, exclude=exclude, round_trip=True)
    data = {**data, **(update or {})}
    copied = self.model_validate(data)
    ```

    Args:
        include: Optional set or mapping specifying which fields to include in the copied model.
        exclude: Optional set or mapping specifying which fields to exclude in the copied model.
        update: Optional dictionary of field-value pairs to override field values in the copied model.
        deep: If True, the values of fields that are Pydantic models will be deep-copied.

    Returns:
        A copy of the model with included, excluded and updated fields as specified.
    """
    warnings.warn(
        'The `copy` method is deprecated; use `model_copy` instead. '
        'See the docstring of `BaseModel.copy` for details about how to handle `include` and `exclude`.',
        category=PydanticDeprecatedSince20,
        stacklevel=2,
    )
    from .deprecated import copy_internals

    values = dict(
        copy_internals._iter(
            self, to_dict=False, by_alias=False, include=include, exclude=exclude, exclude_unset=False
        ),
        **(update or {}),
    )
    if self.__pydantic_private__ is None:
        private = None
    else:
        private = {k: v for k, v in self.__pydantic_private__.items() if v is not PydanticUndefined}

    if self.__pydantic_extra__ is None:
        extra: dict[str, Any] | None = None
    else:
        extra = self.__pydantic_extra__.copy()
        for k in list(self.__pydantic_extra__):
            if k not in values:  # k was in the exclude
                extra.pop(k)
        for k in list(values):
            if k in self.__pydantic_extra__:  # k must have come from extra
                extra[k] = values.pop(k)

    # new `__pydantic_fields_set__` can have unset optional fields with a set value in `update` kwarg
    if update:
        fields_set = self.__pydantic_fields_set__ | update.keys()
    else:
        fields_set = set(self.__pydantic_fields_set__)

    # removing excluded fields from `__pydantic_fields_set__`
    if exclude:
        fields_set -= set(exclude)

    return copy_internals._copy_and_set_values(self, values, fields_set, extra, private, deep=deep)

def get_initial_debug_info(self) -> dict[str, Any]:
    """Get the debug information for the chat event"""

    # TODO: Make sure this coincides with what is shown in the first user message
    return {
        "user_metadata": self.payload.user_metadata,
        "tool_parameters": self.payload.tool_parameters,
        "chosen_module": self.payload.name,
        "assistant": {"id": self.payload.assistant_id},
    }

@_utils.deprecated_instance_property
@classmethod
def model_computed_fields(cls) -> dict[str, ComputedFieldInfo]:
    """A mapping of computed field names to their respective [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] instances.

    !!! warning
        Accessing this attribute from a model instance is deprecated, and will not work in Pydantic V3.
        Instead, you should access this attribute from the model class.
    """
    return getattr(cls, '__pydantic_computed_fields__', {})

@classmethod
def model_construct(cls, _fields_set: set[str] | None = None, **values: Any) -> Self:  # noqa: C901
    """Creates a new instance of the `Model` class with validated data.

    Creates a new model setting `__dict__` and `__pydantic_fields_set__` from trusted or pre-validated data.
    Default values are respected, but no other validation is performed.

    !!! note
        `model_construct()` generally respects the `model_config.extra` setting on the provided model.
        That is, if `model_config.extra == 'allow'`, then all extra passed values are added to the model instance's `__dict__`
        and `__pydantic_extra__` fields. If `model_config.extra == 'ignore'` (the default), then all extra passed values are ignored.
        Because no validation is performed with a call to `model_construct()`, having `model_config.extra == 'forbid'` does not result in
        an error if extra values are passed, but they will be ignored.

    Args:
        _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
            this is directly used for the [`model_fields_set`][pydantic.BaseModel.model_fields_set] attribute.
            Otherwise, the field names from the `values` argument will be used.
        values: Trusted or pre-validated data dictionary.

    Returns:
        A new instance of the `Model` class with validated data.
    """
    m = cls.__new__(cls)
    fields_values: dict[str, Any] = {}
    fields_set = set()

    for name, field in cls.__pydantic_fields__.items():
        if field.alias is not None and field.alias in values:
            fields_values[name] = values.pop(field.alias)
            fields_set.add(name)

        if (name not in fields_set) and (field.validation_alias is not None):
            validation_aliases: list[str | AliasPath] = (
                field.validation_alias.choices
                if isinstance(field.validation_alias, AliasChoices)
                else [field.validation_alias]
            )

            for alias in validation_aliases:
                if isinstance(alias, str) and alias in values:
                    fields_values[name] = values.pop(alias)
                    fields_set.add(name)
                    break
                elif isinstance(alias, AliasPath):
                    value = alias.search_dict_for_path(values)
                    if value is not PydanticUndefined:
                        fields_values[name] = value
                        fields_set.add(name)
                        break

        if name not in fields_set:
            if name in values:
                fields_values[name] = values.pop(name)
                fields_set.add(name)
            elif not field.is_required():
                fields_values[name] = field.get_default(call_default_factory=True, validated_data=fields_values)
    if _fields_set is None:
        _fields_set = fields_set

    _extra: dict[str, Any] | None = values if cls.model_config.get('extra') == 'allow' else None
    _object_setattr(m, '__dict__', fields_values)
    _object_setattr(m, '__pydantic_fields_set__', _fields_set)
    if not cls.__pydantic_root_model__:
        _object_setattr(m, '__pydantic_extra__', _extra)

    if cls.__pydantic_post_init__:
        m.model_post_init(None)
        # update private attributes with values set
        if hasattr(m, '__pydantic_private__') and m.__pydantic_private__ is not None:
            for k, v in values.items():
                if k in m.__private_attributes__:
                    m.__pydantic_private__[k] = v

    elif not cls.__pydantic_root_model__:
        # Note: if there are any private attributes, cls.__pydantic_post_init__ would exist
        # Since it doesn't, that means that `__pydantic_private__` should be set to None
        _object_setattr(m, '__pydantic_private__', None)

    return m

def model_copy(self, *, update: Mapping[str, Any] | None = None, deep: bool = False) -> Self:
    """!!! abstract "Usage Documentation"
        [`model_copy`](../concepts/models.md#model-copy)

    Returns a copy of the model.

    !!! note
        The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
        might have unexpected side effects if you store anything in it, on top of the model
        fields (e.g. the value of [cached properties][functools.cached_property]).

    Args:
        update: Values to change/add in the new model. Note: the data is not validated
            before creating the new model. You should trust this data.
        deep: Set to `True` to make a deep copy of the model.

    Returns:
        New model instance.
    """
    copied = self.__deepcopy__() if deep else self.__copy__()
    if update:
        if self.model_config.get('extra') == 'allow':
            for k, v in update.items():
                if k in self.__pydantic_fields__:
                    copied.__dict__[k] = v
                else:
                    if copied.__pydantic_extra__ is None:
                        copied.__pydantic_extra__ = {}
                    copied.__pydantic_extra__[k] = v
        else:
            copied.__dict__.update(update)
        copied.__pydantic_fields_set__.update(update.keys())
    return copied